1class Document:
2    def __init__(self, id: str, title: str, content: str):
3        self.id = id
4        self.title = title
5        self.content = content
6
7    def get_id(self) -> str:
8        return self.id
9
10    def get_title(self) -> str:
11        return self.title
12
13    def get_content(self) -> str:
14        return self.content
15
16    def __str__(self) -> str:
17        return f"Document(id={self.id}, title='{self.title}')"

1class DocumentStore:
2    def __init__(self):
3        self.store: Dict[str, Document] = {}
4
5    def add_document(self, doc: Document):
6        self.store[doc.get_id()] = doc
7
8    def get_document(self, doc_id: str) -> Optional[Document]:
9        return self.store.get(doc_id)

1class Posting:
2    def __init__(self, document_id: str, frequency: int):
3        self.document_id = document_id
4        self.frequency = frequency
5
6    def get_document_id(self) -> str:
7        return self.document_id
8
9    def get_frequency(self) -> int:
10        return self.frequency

1class InvertedIndex:
2    def __init__(self):
3        self.index: Dict[str, List[Posting]] = defaultdict(list)
4
5    def add(self, term: str, document_id: str, frequency: int):
6        postings = self.index.get(term, [])
7        postings.append(Posting(document_id, frequency))
8        self.index[term] = postings
9
10    def get_postings(self, term: str) -> List[Posting]:
11        return self.index.get(term, [])

1class SearchResult:
2    def __init__(self, document: Document, score: float):
3        self.document = document
4        self.score = score
5
6    def get_document(self) -> Document:
7        return self.document
8
9    def get_score(self) -> float:
10        return self.score
11
12    def __str__(self) -> str:
13        return f"  - {self.document.get_title()} (Score: {self.score:.2f})"

1class ScoringStrategy(ABC):
2    @abstractmethod
3    def calculate_score(self, term: str, posting: Posting, document: Document) -> float:
4        pass
5
6class TermFrequencyScoringStrategy(ScoringStrategy):
7    def calculate_score(self, term: str, posting: Posting, document: Document) -> float:
8        return posting.get_frequency()
9
10class TitleBoostScoringStrategy(ScoringStrategy):
11    TITLE_BOOST_FACTOR = 1.5
12
13    def calculate_score(self, term: str, posting: Posting, document: Document) -> float:
14        score = posting.get_frequency()
15        if term in document.get_title().lower():
16            score *= self.TITLE_BOOST_FACTOR
17        return score

1class RankingStrategy(ABC):
2    @abstractmethod
3    def rank(self, results: List[SearchResult]):
4        pass
5
6class ScoreBasedRankingStrategy(RankingStrategy):
7    def rank(self, results: List[SearchResult]):
8        results.sort(key=lambda x: x.get_score(), reverse=True)
9
10class ScoreThenAlphabeticalRankingStrategy(RankingStrategy):
11    def rank(self, results: List[SearchResult]):
12        results.sort(key=lambda x: (-x.get_score(), x.get_document().get_title()))

1class SearchEngine:
2    _instance = None
3
4    def __new__(cls):
5        if cls._instance is None:
6            cls._instance = super().__new__(cls)
7        return cls._instance
8
9    def __init__(self):
10        if hasattr(self, '_initialized'):
11            return
12        self._initialized = True
13        self.inverted_index = InvertedIndex()
14        self.document_store = DocumentStore()
15        self.scoring_strategy = None
16        self.ranking_strategy = None
17
18    @classmethod
19    def get_instance(cls):
20        if cls._instance is None:
21            cls._instance = cls()
22        return cls._instance
23
24    def set_scoring_strategy(self, scoring_strategy: ScoringStrategy):
25        self.scoring_strategy = scoring_strategy
26
27    def set_ranking_strategy(self, ranking_strategy: RankingStrategy):
28        self.ranking_strategy = ranking_strategy
29
30    def index_documents(self, documents: List[Document]):
31        for doc in documents:
32            self.index_document(doc)
33
34    def index_document(self, doc: Document):
35        self.document_store.add_document(doc)
36        term_frequencies: Dict[str, int] = {}
37
38        text = (doc.get_title() + " " + doc.get_content()).lower()
39        tokens = re.split(r'\W+', text)
40
41        for token in tokens:
42            if token:
43                term_frequencies[token] = term_frequencies.get(token, 0) + 1
44
45        for term, frequency in term_frequencies.items():
46            self.inverted_index.add(term, doc.get_id(), frequency)
47
48    def search(self, query: str) -> List[SearchResult]:
49        processed_query = query.lower()
50
51        postings = self.inverted_index.get_postings(processed_query)
52
53        results = []
54        for posting in postings:
55            doc = self.document_store.get_document(posting.get_document_id())
56            if doc is not None:
57                score = self.scoring_strategy.calculate_score(processed_query, posting, doc)
58                results.append(SearchResult(doc, score))
59
60        self.ranking_strategy.rank(results)
61
62        return results

1class SearchEngineDemo:
2    @staticmethod
3    def main():
4        engine = SearchEngine.get_instance()
5
6        documents = [
7            Document("doc1", "Java Performance", "Java is a high-performance language. Tuning Java applications is key."),
8            Document("doc2", "Introduction to Python", "Python is a versatile language, great for beginners."),
9            Document("doc3", "Advanced Java Concepts", "This document covers advanced topics in Java programming."),
10            Document("doc4", "Python vs. Java", "A document comparing Python and Java for web development. Java is faster.")
11        ]
12
13        print("Indexing documents...")
14        engine.index_documents(documents)
15        print("Indexing complete.\n")
16
17        print("====== TermFrequency Scoring + ScoreBased Ranking ======")
18        engine.set_scoring_strategy(TermFrequencyScoringStrategy())
19        engine.set_ranking_strategy(ScoreBasedRankingStrategy())
20
21        SearchEngineDemo.perform_search(engine, "java")
22        SearchEngineDemo.perform_search(engine, "language")
23        SearchEngineDemo.perform_search(engine, "performance")
24
25        print("\n====== TitleBoost Scoring + Score-then-Alphabetical Ranking ======")
26        engine.set_scoring_strategy(TitleBoostScoringStrategy())
27        engine.set_ranking_strategy(ScoreThenAlphabeticalRankingStrategy())
28
29        SearchEngineDemo.perform_search(engine, "java")
30        SearchEngineDemo.perform_search(engine, "language")
31        SearchEngineDemo.perform_search(engine, "performance")
32
33        SearchEngineDemo.perform_search(engine, "paint")
34
35    @staticmethod
36    def perform_search(engine: SearchEngine, query: str):
37        print(f"--- Searching for: '{query}' ---")
38        results = engine.search(query)
39
40        if not results:
41            print("  No results found.")
42        else:
43            for i, result in enumerate(results):
44                print(f"Rank {i + 1}:{result}")
45        print()
46
47
48if __name__ == "__main__":
49    SearchEngineDemo.main()